(after the recent changes).
Signed-off-by: Stefan Berger <stefanb@us.ibm.com>
}
-value of the field
-\vspace{0.3cm}
-\vspace{0.3cm}
-\vspace{0.3cm}
-\subsubsection{RPC name:~get\_instance}
-
-{\bf Overview:}
-Get the instance field of the given VTPM.
-
- \noindent {\bf Signature:}
-\begin{verbatim} int get_instance (session_id s, VTPM ref self)\end{verbatim}
-
-
-\noindent{\bf Arguments:}
-
-
-\vspace{0.3cm}
-\begin{tabular}{|c|c|p{7cm}|}
- \hline
-{\bf type} & {\bf name} & {\bf description} \\ \hline
-{\tt VTPM ref } & self & reference to the object \\ \hline
-
-\end{tabular}
-
-\vspace{0.3cm}
-
- \noindent {\bf Return Type:}
-{\tt
-int
-}
-
-
value of the field
\vspace{0.3cm}
\vspace{0.3cm}
extern bool
xen_vtpm_get_backend(xen_session *session, xen_vm *result, xen_vtpm vtpm);
-
-/**
- * Get the instance field of the given VTPM.
- */
-extern bool
-xen_vtpm_get_instance(xen_session *session, int64_t *result, xen_vtpm vtpm);
-
-
#endif
{ .key = "backend",
.type = &abstract_type_ref,
.offset = offsetof(xen_vtpm_record, backend) },
- { .key = "instance",
- .type = &abstract_type_int,
- .offset = offsetof(xen_vtpm_record, instance) }
};
const abstract_type xen_vtpm_record_abstract_type_ =
}
-bool
-xen_vtpm_get_instance(xen_session *session, int64_t *result, xen_vtpm vtpm)
-{
- abstract_value param_values[] =
- {
- { .type = &abstract_type_string,
- .u.string_val = vtpm }
- };
-
- abstract_type result_type = abstract_type_int;
-
- XEN_CALL_("VTPM.get_instance");
- return session->ok;
-}
-
-
bool
xen_vtpm_get_uuid(xen_session *session, char **result, xen_vtpm vtpm)
{
print "Creating vTPM with cfg = %s" % cfg
vtpm_uuid = execute(server, 'VTPM.create', (session, cfg))
print "Done. (%s)" % vtpm_uuid
- vtpm_id = execute(server, 'VTPM.get_instance', (session, vtpm_uuid))
- print "Has instance number '%s'" % vtpm_id
- vtpm_be = execute(server, 'VTPM.get_backend', (session, vtpm_uuid))
- print "Has backend in '%s'" % vtpm_be
- driver = execute(server, 'VTPM.get_driver', (session, vtpm_uuid))
- print "Has driver type '%s'" % driver
- vtpm_rec = execute(server, 'VTPM.get_record', (session, vtpm_uuid))
- print "Has vtpm record '%s'" % vtpm_rec
def xapi_pif_list(args, async = False):
VTPM_attr_rw = [ ]
VTPM_attr_ro = ['VM',
- 'backend',
- 'instance']
+ 'backend']
VTPM_attr_inst = VTPM_attr_rw
return xen_api_error(['VTPM_HANDLE_INVALID', vtpm_ref])
valid_vtpm_keys = self.VTPM_attr_ro + self.VTPM_attr_rw + \
self.Base_attr_ro + self.Base_attr_rw
+ return_cfg = {}
for k in cfg.keys():
- if k not in valid_vtpm_keys:
- del cfg[k]
+ if k in valid_vtpm_keys:
+ return_cfg[k] = cfg[k]
- return xen_api_success(cfg)
+ return xen_api_success(return_cfg)
# Class Functions
- def VTPM_get_instance(self, session, vtpm_ref):
- xendom = XendDomain.instance()
- vm = xendom.get_vm_with_dev_uuid('vtpm', vtpm_ref)
- if not vm:
- return xen_api_error(['VTPM_HANDLE_INVALID', vtpm_ref])
- cfg = vm.get_dev_xenapi_config('vtpm', vtpm_ref)
- if not cfg:
- return xen_api_error(['VTPM_HANDLE_INVALID', vtpm_ref])
- if cfg.has_key('instance'):
- instance = cfg['instance']
- else:
- instance = -1
- return xen_api_success(instance)
-
def VTPM_get_backend(self, session, vtpm_ref):
xendom = XendDomain.instance()
vm = xendom.get_vm_with_dev_uuid('vtpm', vtpm_ref)
cfg = vm.get_dev_xenapi_config('vtpm', vtpm_ref)
if not cfg:
return xen_api_error(['VTPM_HANDLE_INVALID', vtpm_ref])
- if cfg.has_key('backend'):
- backend = cfg['backend']
- else:
- backend = "Domain-0"
- return xen_api_success(backend)
+ if not cfg.has_key('backend'):
+ return xen_api_error(['VTPM backend not set'])
+ return xen_api_success(cfg['backend'])
def VTPM_get_VM(self, session, vtpm_ref):
xendom = XendDomain.instance()
def VTPM_destroy(self, session, vtpm_ref):
xendom = XendDomain.instance()
- vm = xendom.get_vm_with_dev_uuid('vtpm', vtpm_ref)
- if not vm:
- return xen_api_error(['VTPM_HANDLE_INVALID', vtpm_ref])
-
- vm.destroy_vtpm(vtpm_ref)
- return xen_api_success_void()
+ dom = xendom.get_vm_with_dev_uuid('vtpm', vtpm_ref)
+ if dom:
+ if dom.state != XEN_API_VM_POWER_STATE_HALTED:
+ vm_ref = dom.get_dev_property('vtpm', vtpm_ref, 'VM')
+ return xen_api_error(['VM_BAD_POWER_STATE', vm_ref,
+ XendDomain.POWER_STATE_NAMES[XEN_API_VM_POWER_STATE_HALTED],
+ XendDomain.POWER_STATE_NAMES[dom.state]])
+ from xen.xend.server import tpmif
+ tpmif.destroy_vtpmstate(dom.getName())
+ return xen_api_success(True)
+ else:
+ return xen_api_error(['VM_HANDLE_INVALID', vtpm_struct['VM']])
# class methods
def VTPM_create(self, session, vtpm_struct):
config['mode'] = 'RW'
if dev_class == 'vtpm':
- config['driver'] = 'paravirtualised' # TODO
+ if not config.has_type('type'):
+ config['type'] = 'paravirtualised' # TODO
+ if not config.has_key('backend'):
+ config['backend'] = "00000000-0000-0000-0000-000000000000"
return config
# Author: Stefan Berger <stefanb@us.ibm.com>
# Test to test the vtpm class through the Xen-API
+#
+# Tested methods:
+# VTPM: get_uuid, get_backend, get_by_uuid, get_record
+# create, destroy, get_VM
+# VM: get_VTPMS
from XmTestLib import xapi
from XmTestLib.XenAPIDomain import XmTestAPIDomain
from XmTestLib import *
+from xen.xend import XendDomain
from vtpm_utils import *
import commands
import os
+VTPM_RECORD_KEYS = [ 'backend', 'VM', 'uuid' ]
+
try:
# XmTestAPIDomain tries to establish a connection to XenD
domain = XmTestAPIDomain()
vm_uuid = domain.get_uuid()
vtpmcfg = {}
-vtpmcfg['type'] = "paravirtualised"
-vtpmcfg['backend'] = "Domain-0"
-vtpmcfg['instance'] = 1
+vtpmcfg['backend'] = XendDomain.DOM0_UUID
vtpmcfg['VM'] = vm_uuid
session = xapi.connect()
vtpm_uuid = session.xenapi.VTPM.create(vtpmcfg)
-vtpm_id = session.xenapi.VTPM.get_instance(vtpm_uuid)
vtpm_be = session.xenapi.VTPM.get_backend(vtpm_uuid)
if vtpm_be != vtpmcfg['backend']:
FAIL("vTPM's backend is in '%s', expected: '%s'" %
(vtpm_be, vtpmcfg['backend']))
-driver = session.xenapi.VTPM.get_driver(vtpm_uuid)
-if driver != vtpmcfg['type']:
- FAIL("vTPM has driver type '%s', expected: '%s'" %
- (driver, vtpmcfg['type']))
-
vtpm_rec = session.xenapi.VTPM.get_record(vtpm_uuid)
-if vtpm_rec['driver'] != vtpmcfg['type']:
- FAIL("vTPM record shows driver type '%s', expected: '%s'" %
- (vtpm_rec['driver'], vtpmcfg['type']))
+miss_keys = []
+for k in VTPM_RECORD_KEYS:
+ if k not in vtpm_rec.keys():
+ miss_keys.append(k)
+if len(miss_keys) > 0:
+ FAIL("vTPM record is missing key(s): %s" % miss_keys)
+
if vtpm_rec['uuid'] != vtpm_uuid:
FAIL("vTPM record shows vtpm uuid '%s', expected: '%s'" %
(vtpm_rec['uuid'], vtpm_uuid))
if vtpm_rec['VM'] != vm_uuid:
FAIL("vTPM record shows VM uuid '%s', expected: '%s'" %
(vtpm_rec['VM'], vm_uuid))
+if vtpm_rec['backend'] != vtpmcfg['backend']:
+ FAIL("vTPM record shows VM bakcned '%s', expected: '%s'" %
+ (vtpm_rev['backend'], vtpmcfg['backend']))
+
+badkeys = []
+keys = vtpm_rec.keys()
+for k in keys:
+ if k not in VTPM_RECORD_KEYS:
+ badkeys.append(k)
+if len(badkeys) > 0:
+ FAIL("Unexpected attributes in result: %s" % badkeys)
+
+if vm_uuid != session.xenapi.VTPM.get_VM(vtpm_uuid):
+ FAIL("VM uuid from VTPM.get_VM different (%s) than expected (%s)." %
+ (vm_ref, vm_uuid))
+
+uuid = session.xenapi.VTPM.get_uuid(vtpm_uuid)
+if uuid != vtpm_uuid:
+ FAIL("vTPM from VTPM.get_uuid different (%s) than expected (%s)." %
+ (uuid, vtpm_uuid))
+
+vtpm_ref = session.xenapi.VTPM.get_by_uuid(vtpm_uuid)
+if vtpm_ref != vtpm_uuid:
+ FAIL("vTPM from VTPM.get_by_uuid different (%s) than expected (%s)." %
+ (vtpm_ref, vtpm_uuid))
+
+vm_vtpms = session.xenapi.VM.get_VTPMs(vm_uuid)
+if len(vm_vtpms) != 1:
+ FAIL("Number of vTPMs from get_VTPMs is (%d) not what was expected (%d)" %
+ (len(vm_vtpms), 1))
+if vtpm_uuid not in vm_vtpms:
+ FAIL("Other vTPM uuid (%s) returned from VM.get_VTPMs than expected (%s)" %
+ (vm_vtpms[0], vtpm_uuid))
-success = domain.start()
+try:
+ console = domain.start()
+except DomainError, e:
+ FAIL("Unable to create domain (%s)" % domName)
-console = domain.getConsole()
+try:
+ console.sendInput("input")
+except ConsoleError, e:
+ saveLog(console.getHistory())
+ FAIL(str(e))
try:
run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs")
except ConsoleError, e:
saveLog(console.getHistory())
- vtpm_cleanup(domName)
- FAIL("No result from dumping the PCRs")
+ FAIL("1. No result from dumping the PCRs")
if re.search("No such file",run["output"]):
- vtpm_cleanup(domName)
FAIL("TPM frontend support not compiled into (domU?) kernel")
+if not re.search("PCR-00:",run["output"]):
+ saveLog(console.getHistory())
+ FAIL("1. Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"])
+
+try:
+ rc = session.xenapi.VTPM.destroy(vtpm_uuid)
+ #Should never get here
+ FAIL("Could destroy vTPM while VM is running")
+except:
+ pass
+
+rc = session.xenapi.VM.suspend(vm_uuid)
+if rc:
+ FAIL("Could not suspend VM")
+
+try:
+ rc = session.xenapi.VTPM.destroy(vtpm_uuid)
+ #May not throw an exception in 'suspend' state
+except:
+ pass
+
+rc = session.xenapi.VM.resume(vm_uuid, False)
+if rc:
+ FAIL("Could not resume VM")
+
+try:
+ console = domain.getConsole()
+except ConsoleError, e:
+ FAIL(str(e))
+
+try:
+ run = console.runCmd("cat /sys/devices/xen/vtpm-0/pcrs")
+except ConsoleError, e:
+ saveLog(console.getHistory())
+ FAIL("2. No result from dumping the PCRs. vTPM has been removed?")
+
+if not re.search("PCR-00:",run["output"]):
+ saveLog(console.getHistory())
+ FAIL("2. Virtual TPM is not working correctly on /dev/vtpm on backend side: \n%s" % run["output"])
+
domain.stop()
+
+rc = session.xenapi.VTPM.destroy(vtpm_uuid)
+if not rc:
+ FAIL("Could NOT destroy vTPM while domain is halted.")
+
domain.destroy()
projects / xen.git / commitdiff